📚 Week 4 · Unit III · Lecture 12
DevOps Toolkit;
Intro to CI/CD

Mapping the complete DevOps toolchain — from code to production — and diving deep into Continuous Integration and Continuous Delivery pipelines as the engine of modern software delivery.

Dr. Mohsin Furkh DarSchool of Computer Sciences
DateTue, 30 Jun 2026 · 9:00 – 10:00 AM
ProgrammeBTech CSE – Summer Semester
Today's Agenda
1
Recap — Unit II Wrap-Up & Welcome to Unit III
2
The DevOps Toolchain — Plan to Operate
3
Tool Categories & Popular Choices
4
CI Deep Dive — Continuous Integration
5
CD Deep Dive — Delivery vs. Deployment
6
Building a CI/CD Pipeline & Key Takeaways
Recap & Transition
From Principles to Tools
✅
Unit II Complete: We covered the full DevOps philosophy — Agile + DevOps, MVP, CI/CD concepts, the CAMS framework (Culture, Automation, Measurement, Sharing), TDD, Configuration Management, Infrastructure Automation, RCA, Blamelessness, and Organizational Learning.
🎯
Unit III begins: Now we move from "what DevOps is" to "what tools DevOps uses." This unit maps the complete DevOps toolchain and goes hands-on with CI/CD pipelines and version control systems.
Unit II — Principles ✔️
  • CAMS framework — the "why" of DevOps
  • CI/CD — the concept (what it means)
  • IaC & Configuration Management
  • Blamelessness & learning culture
Unit III — Toolkit 📍
  • Concrete tools for each DevOps phase
  • CI/CD — the tooling (Jenkins, GitHub Actions, etc.)
  • Version Control Systems — Git in depth
  • Hands-on pipeline construction
The Big Picture
The DevOps Toolchain — End to End

The DevOps toolchain spans the entire software lifecycle — from planning a feature to operating it in production. Each phase has specialized tools, but they all connect into a continuous flow.

PlanIdeas & tasks
CodeWrite & review
BuildCompile & package
TestVerify quality
ReleaseApprove & tag
DeployShip to prod
OperateRun & scale
MonitorObserve & alert
♻️
It's an infinity loop, not a straight line. The DevOps toolchain is often drawn as an ∞ symbol — the left loop (Plan → Code → Build → Test) is the "Dev" side, and the right loop (Release → Deploy → Operate → Monitor) is the "Ops" side. Monitoring feeds back into planning — closing the loop.
🔑 Key Principle

Tools enable, but don't define DevOps. A team with the wrong culture but perfect tools will still fail. But a team with the right culture and the right tools can deliver software faster and more reliably than either alone. Tools are the force multiplier.

Toolchain — Plan & Code
Planning & Coding Tools
📋 Plan
  • Jira — industry-standard project tracking, sprints, backlogs, Kanban boards
  • Azure Boards — Microsoft's integrated planning tool (part of Azure DevOps)
  • Trello — simple Kanban-style boards for smaller teams
  • Linear — modern, fast issue tracker popular with startups
  • GitHub Issues / Projects — lightweight planning directly in your code repo
💻 Code
  • VS Code — dominant code editor with rich extension ecosystem
  • Git — distributed version control (we'll study this in depth in L13–14)
  • GitHub / GitLab / Bitbucket — hosted Git repositories with collaboration features
  • Code Review Tools — pull requests, Gerrit, Crucible
  • AI Assistants — GitHub Copilot, Gemini Code Assist — AI-powered code generation
📊
Jira
Planning
📝
VS Code
Editor
🔀
Git
VCS
🐙
GitHub
Platform
🦊
GitLab
Platform
Toolchain — Build & Test
Build & Test Tools
🔨 Build
  • Maven / Gradle — Java project build & dependency management
  • npm / Yarn / pnpm — JavaScript/Node.js package managers & build tools
  • Docker — builds container images from Dockerfiles
  • Webpack / Vite — frontend bundlers that compile, minify, and optimize
  • Make / CMake — classic build automation for C/C++ and polyglot projects
🧪 Test
  • JUnit / TestNG — Java unit testing frameworks
  • pytest — Python testing framework (simple, powerful)
  • Jest / Mocha — JavaScript testing frameworks
  • Selenium / Playwright / Cypress — browser-based UI/E2E testing
  • SonarQube — code quality and security analysis (static analysis)
☕
Maven
Build
🐳
Docker
Build + Run
🧪
pytest
Testing
🎭
Playwright
E2E Testing
🔍
SonarQube
Quality
⚡
The build + test combination is the heart of CI. Every code push triggers a build, and every build runs automated tests. If either fails, the pipeline stops and the developer is notified immediately — catching bugs within minutes, not weeks.
Toolchain — Release to Monitor
Release, Deploy, Operate & Monitor
🏷️
Release
Tools: GitHub Releases, GitLab Release, semantic-release. Tag a version, generate changelogs, approve for deployment. Release ≠ Deploy — release means "it's ready," deploy means "it's live."
🚀
Deploy
Tools: Kubernetes, Helm, ArgoCD, AWS CodeDeploy, Ansible. Push the released artifact to production environments. Strategies: blue-green, canary, rolling update.
⚙️
Operate
Tools: Kubernetes, Terraform, Ansible, PagerDuty. Keep the system running — scaling, patching, incident response, on-call rotation, and runbook execution.
📊
Monitor
Tools: Prometheus, Grafana, Datadog, ELK Stack (Elasticsearch, Logstash, Kibana), New Relic. Collect metrics, logs, and traces — then alert when things go wrong.
☸️
Kubernetes
Deploy + Operate
🔥
Prometheus
Monitoring
📈
Grafana
Dashboards
🐕
Datadog
Observability
📟
PagerDuty
Incident Mgmt
Reference
DevOps Toolchain — Complete Map

A single reference table mapping every DevOps phase to its category and the most popular tools in the industry.

Phase Category Popular Tools
Plan Project Management Jira, Azure Boards, Linear, Trello, GitHub Projects
Code VCS & Editors Git, GitHub, GitLab, Bitbucket, VS Code
Build Build Automation Maven, Gradle, npm, Docker, Webpack, Vite
Test Testing Frameworks JUnit, pytest, Jest, Selenium, Playwright, SonarQube
CI/CD Pipeline Engines Jenkins, GitHub Actions, GitLab CI, CircleCI, Travis CI
Release Artifact & Registry Docker Hub, Nexus, JFrog Artifactory, GitHub Packages
Deploy Deployment & Orchestration Kubernetes, Helm, ArgoCD, Ansible, Terraform
Operate Infrastructure & Incident Kubernetes, Terraform, PagerDuty, Opsgenie
Monitor Observability Prometheus, Grafana, Datadog, ELK Stack, New Relic
💡
No single tool covers everything. DevOps teams assemble a toolchain — a curated set of tools that integrate well together. Many organizations adopt all-in-one platforms (GitLab, Azure DevOps, GitHub) to reduce integration overhead while still adding specialized tools where needed.
CI/CD Introduction
What Is CI/CD? — The Engine of DevOps
🔄
CI/CD stands for Continuous Integration and Continuous Delivery / Deployment. It's the automated pipeline that takes code from a developer's laptop to production — building, testing, and deploying it with minimal human intervention.

CI/CD is not a tool — it's a practice backed by tools. The practice says: integrate frequently, test automatically, deliver reliably. The tools make that practice possible at scale.

— Martin Fowler, ThoughtWorks
CI
Continuous
Integration
CD
Continuous
Delivery
CD
Continuous
Deployment
⚠️
Note the two "CD"s: Continuous Delivery means the code is always in a deployable state, but a human approves the final push to production. Continuous Deployment means every passing build goes to production automatically — no human gate. Most teams start with Delivery and graduate to Deployment.
Continuous Integration
CI — Integrate Early, Integrate Often

Continuous Integration is the practice of merging all developer working copies to a shared mainline multiple times a day, with each merge verified by an automated build and test suite.

1
Developer Commits Code
A developer finishes a small unit of work and pushes it to the shared repository (e.g., a Git push to a feature branch, then opens a Pull Request).
2
CI Server Detects Change
The CI server (Jenkins, GitHub Actions, etc.) detects the new commit via a webhook and triggers a pipeline run automatically.
3
Build & Compile
The pipeline compiles the code, resolves dependencies, and produces a build artifact (JAR, Docker image, binary). If the build fails — pipeline stops, developer is notified.
4
Run Automated Tests
Unit tests, integration tests, and linting run automatically. If any test fails — pipeline stops, developer is notified. Fast feedback: typically under 10 minutes.
5
Report Results
Green ✅ = code is safe to merge. Red ❌ = something broke, fix it before merging. Results appear directly on the Pull Request — visible to the whole team.
🔑 CI Rules

1. Commit at least once a day. 2. Every commit triggers a build. 3. Fix broken builds immediately — never leave the pipeline red. 4. Keep the build fast (< 10 minutes). 5. Test in a production-like environment.

Continuous Delivery & Deployment
CD — From Build to Production

After CI ensures the code is buildable and passes tests, CD extends the pipeline to package, stage, and deploy the software — either with a manual approval gate (Delivery) or fully automatically (Deployment).

CommitDeveloper
BuildCI server
TestAutomated
StagePre-prod
Approve?Human gate
ProductionLive!
🚢 Continuous Delivery
  • Code is always in a deployable state after passing CI
  • Deployed to staging automatically for further testing
  • A human approves the final push to production
  • Suitable for: regulated industries, critical systems, teams starting with DevOps
  • Example: GitHub's ship-it workflow — PR merged → staging → PM clicks "Deploy"
⚡ Continuous Deployment
  • Every commit that passes all tests goes to production automatically
  • No human gate — full automation from commit to live
  • Requires: excellent test coverage, feature flags, monitoring
  • Suitable for: mature teams, SaaS products, low-risk changes
  • Example: Netflix deploys hundreds of times per day — fully automated
CI/CD Tooling
Popular CI/CD Tools

The CI/CD market has evolved from monolithic servers (Jenkins) to cloud-native, YAML-based pipeline-as-code platforms.

Tool Type Pipeline Definition Key Strength
Jenkins Self-hosted Jenkinsfile (Groovy) Mature, 1800+ plugins, highly customizable
GitHub Actions Cloud (GitHub) YAML workflows Deep GitHub integration, marketplace of actions
GitLab CI Cloud / Self-hosted .gitlab-ci.yml All-in-one platform (VCS + CI/CD + Registry)
CircleCI Cloud YAML config Fast execution, excellent Docker support
Azure Pipelines Cloud (Azure) YAML / GUI Deep Azure integration, multi-platform
ArgoCD Kubernetes-native GitOps (Git repos) Declarative, Git-driven deployments for K8s
📈
Industry trend: The market is shifting from self-hosted (Jenkins) to cloud-native, pipeline-as-code platforms (GitHub Actions, GitLab CI). The advantage: no server maintenance, built-in runners, and tight VCS integration. Jenkins remains dominant in enterprises with existing investments.
Hands-On Example
A Real CI/CD Pipeline — GitHub Actions

Here's a complete CI pipeline defined in a single YAML file. This file lives in your repo at .github/workflows/ci.yml.

# .github/workflows/ci.yml
name: CI Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Install dependencies
        run: npm ci

      - name: Run linter
        run: npm run lint

      - name: Run tests
        run: npm test

      - name: Build application
        run: npm run build
📄
Pipeline-as-Code: The pipeline definition lives in the same repository as the application code. It's version controlled, code-reviewed via PRs, and treated exactly like application code. This is a key DevOps principle — everything as code.
Deployment Strategies
How Code Reaches Production

Not all deployments are the same. Different strategies balance speed, risk, and resource usage.

🔄
Rolling Update
Replace instances one-by-one with the new version. At any point, both old and new versions are running. Used by: Kubernetes default. Risk: low, but rollback is slow.
🔵🟢
Blue-Green
Run two identical environments (Blue = current, Green = new). Switch traffic from Blue to Green in one step. Benefit: instant rollback — just switch back. Cost: double the infrastructure.
🐦
Canary Release
Route a small % of traffic (e.g., 5%) to the new version. Monitor for errors. If stable, gradually increase to 100%. Benefit: minimal blast radius. Used by: Netflix, Google.
🚩
Feature Flags
Deploy the code to production but hide the feature behind a toggle. Enable for specific users or groups. Benefit: decouple deployment from release. Tools: LaunchDarkly, Unleash.
💡 Strategy Selection

Rolling: for routine, low-risk updates. Blue-Green: when instant rollback is critical. Canary: for user-facing changes with uncertain impact. Feature Flags: when you want to deploy daily but release features independently. Most mature teams combine all four.

Maturity
CI/CD Maturity Model

Teams don't jump to full CI/CD overnight. Here's the typical progression from manual to fully automated delivery.

L0
Level 0 — Manual Everything
Builds are run on a developer's machine. Tests are manual. Deployment is via SSH and copy-paste. No version control for infrastructure. "It works on my machine."
L1
Level 1 — Continuous Integration
Automated builds on every commit. Unit tests run automatically. Broken builds are fixed within hours. Code is in a shared Git repository with pull requests.
L2
Level 2 — Continuous Delivery
Automated deployment to staging. Integration + E2E tests. Code is always in a deployable state. Production deployment requires one-click approval.
L3
Level 3 — Continuous Deployment
Every passing commit goes to production automatically. Feature flags control feature visibility. Canary deployments with automated rollback. Full observability.
L4
Level 4 — Continuous Operations
Self-healing infrastructure. Auto-scaling. Chaos engineering. Zero-downtime deployments. The pipeline handles everything — humans focus on innovation, not operations.
Summary
Key Takeaways — Lecture 12

Today we mapped the complete DevOps toolchain and dove deep into CI/CD as the core automation engine of modern software delivery.

01
DevOps ToolchainEight phases: Plan → Code → Build → Test → Release → Deploy → Operate → Monitor — forming an infinity loop where monitoring feeds back into planning.
02
Tool CategoriesEach phase has specialized tools — from Jira (Plan) to Prometheus (Monitor). Teams assemble a toolchain; no single tool covers everything.
03
CI — Continuous IntegrationMerge frequently, build automatically, test every commit. Keep the build fast (<10 min) and fix red builds immediately.
04
CD — Delivery vs. DeploymentDelivery = always deployable + human approval. Deployment = fully automated to production. Most teams progress from Delivery to Deployment.
05
Deployment StrategiesRolling, Blue-Green, Canary, Feature Flags — each balances speed, risk, and cost differently. Mature teams combine multiple strategies.
06
Next: Lecture 13Version Control System overview and the history of SCM — the foundation that makes CI/CD possible.
🎯
Exam tip: Be able to list the 8 phases of the DevOps toolchain with one tool per phase. Know the difference between CI, Continuous Delivery, and Continuous Deployment. Understand all four deployment strategies (rolling, blue-green, canary, feature flags). Be able to read a basic GitHub Actions YAML pipeline.